home *** CD-ROM | disk | FTP | other *** search
/ PsL Monthly 1993 December / PSL Monthly Shareware CD-ROM (December 1993).iso / prgmming / dos / c / i_set.exe / I-SET.C < prev    next >
Encoding:
C/C++ Source or Header  |  1991-09-04  |  19.7 KB  |  761 lines
  1. /* I-SET.c ****************************************************************
  2. A very simple module to allow modification of master
  3. environment under DOS.
  4. External entry points:
  5.  
  6. int iset_load_envstrings (BYTEPTR envblock, char *envstrings[], unsigned *pused)
  7.     Loads the enviromnment in an array of char *. Each entry
  8.     is malloc'd by the function, so it is expected that
  9.     iset_free_envstrings is called after use.
  10.     This routine was originally internal (used by others in this module)
  11.     but it is now public should anyone care. No checking on array
  12.     dimensions!
  13.     If pfree is not NULL, the functions fills it with the number of
  14.     bytes currently used in the environment
  15.  
  16. int iset_free_envstrings (char *envstrings[])
  17.     Frees the copy alloc'd by iset_load_envstrings. It is expected
  18.     that the last valid entry in the array is a zero-length string
  19.     (iset_load_envstrings does this).
  20.  
  21. char *iset_getenv (char *env_par)
  22.     Just like getenv(), only this works on the original environment.
  23.     After use of other functions in this module, the copy which
  24.     is accessed by getenv() could be out of date in respect of
  25.     the master. Used internally also.
  26.  
  27. int iset_set_string (char *env_par, char *env_value)
  28.     Actually a setenv() on the master environment. If a string
  29.     with env_par isn't found, it is added to the environment.
  30.     If env_value is NULL, the string is addedd just like UNIX.
  31.     Note that this routine does attempt to get the strlen()
  32.     of a NULL: in MSC 6.0, the result is 0 and no problem.
  33.     Please look out in other cases.
  34.  
  35. int    iset_append_to_string (char *env_par, char *env_value, int before)
  36.     Adds a new env_value to the end or the beginning
  37.     of the actual value of an environment string, depending
  38.     on before (0: append; 1: insert before).
  39.     If the string didn't exist, it falls
  40.     back to iset_set_string. Otherwise, the string is appended
  41.     with a preceding semi-colon.
  42.  
  43. int iset_cut_string (char *env_par, char *string_to_cut)
  44.     The opposite of iset_append_string. If a string with name
  45.     env_par is found, string_to_cut is searched between pairs
  46.     of semicolons and, if found, the original string is collapsed
  47.     to exclude it. If the string isn't found nothing is done.
  48.  
  49. int iset_delete_string (char *env_par)
  50.     Remove the identified string from the environment. This works
  51.     also on no-value strings which can be produced by
  52.     iset_set_string.
  53.  
  54. int    iset_show_strings (void)
  55.     Will output on stdout the contents of the master environment
  56.     and (little) additional statistics. Useful for seeing variables
  57.     longer than 127 chars, which DOS's set will truncate to 127.
  58.  
  59. This module has been extensively used. Still we don't expect it to
  60. work in every situation! Do complete testings because alteration
  61. of master environment can produce tricky situations to debug.
  62. You can use this source as you like provided you leave this notes
  63. in the module together with the variable id.
  64. Please note that, to assure reentrancy, all functions load a complete
  65. array of pointers (dimension is hardwired) so stack space might
  66. be an issue.
  67.  
  68. I-SET was written by Shari (Davide Migliavacca) of Inferentia S.r.l.,
  69. via Venezian 10, 20123 Milano ITALY.
  70. Tel. +39.2.266680568.
  71. CompuServe 100016,2335
  72. **********************************************************/
  73.  
  74. /* You can't remove this lines */
  75. #define VERSIONE    "3.53"
  76. static const char *id= "I-Set " VERSIONE " " __DATE__ " " __TIME__ " Created by Shari CIS 100016,2335";
  77. /*******************************/
  78.  
  79.  
  80.  
  81. #include <stdio.h>
  82. #include <stdlib.h>
  83. #include <string.h>
  84. #include <dos.h>
  85. #include <options.h>
  86.  
  87.  
  88. /* Should DOS grow beyond this limit, you may put
  89.    a version checking function instead of this macro */
  90. #define dos_max_pathvar_length()    127
  91. int    iset_check_length(char *env_par, int len);
  92.  
  93.  
  94. typedef unsigned char BYTE;
  95. typedef unsigned int WORD;
  96. typedef unsigned long DWORD;
  97. typedef BYTE _far * BYTEPTR;
  98. typedef WORD _far * WORDPTR;
  99. typedef DWORD _far *DWORDPTR;
  100. typedef void _far *FP;
  101.  
  102.  
  103.  
  104. #define MK_FP(seg, off)        ((FP)((DWORD)(((WORD)(off)) | ((DWORD)((WORD)(seg))) << 16 )))
  105.  
  106. #define    INT20h    0xCD20
  107.  
  108. static char terminating_null = '\0';
  109. union REGS regs;
  110.  
  111. typedef struct tagPSP {
  112.     WORD        int20;            /* must be 0xCD20 */
  113.     WORD        alloc_end_seg;        /* segment, end of allocation block */
  114.     BYTE        reserved_1;        
  115.     BYTE        far_call;            /* call far ... next field */
  116.     DWORD    DOS_dispatcher;    /* address of DOS dispatcher */
  117.     DWORD    termination_handler;/* int 22h contents */
  118.     DWORD    ctrl_c_handler;    /* int 23h contents */
  119.     DWORD    crit_err_handler;    /* int 24h contents */
  120.     WORD        parent_PSP;        /* UNDOCUMENTED */
  121.     BYTE        JFT[20];            /* Job file table: UNDOCUMENTED */
  122.     WORD        env_seg;            /* segment of environment block */
  123.     DWORD    reserved_2;        
  124.     WORD        max_opens;        /* # of entries in JFT: UNDOCUMENTED */
  125.     DWORD    actual_JFT;        /* Address of actual JFT: UNDOCUMENTED */
  126.     BYTE        reserved_3[36];
  127.     BYTE        FCB_1[16];        /* Default FCB #1 */
  128.     BYTE        FCB_2[20];        /* Default FCB #2 (overlaid by 1 if used)*/
  129.     BYTE        command_tail[128];    /* command tail and DTA */
  130. } PSP;
  131.  
  132.  
  133. typedef struct tagMCB {
  134.     BYTE        type;
  135.     WORD        owner;    /* PSP of owner */
  136.     WORD        size;
  137.     BYTE        reserved[3];
  138.     BYTE        dos4[8];
  139. } MCB;
  140.  
  141.  
  142. static unsigned env_size(WORD envseg)
  143. {
  144.     unsigned envsize;
  145. _asm {
  146.         mov    ax,envseg             /* get segment of env */
  147.         dec    ax                  /* back up to MCB */
  148.         mov    es,ax
  149.         mov    ax,es:[0003h]       /* get size in grafs */
  150.         mov    envsize, ax
  151.     }
  152.     return envsize << 4;        /* multiply by paragraph size */
  153. }
  154.  
  155.  
  156. /* determines if seg is really a psp:
  157.     1)    at seg-1 there must be a DOS MCB whose owner is seg
  158.     2)    the first two bytes in seg must be 0xCD 0x20 (int 20h)
  159.   From "Undocumented DOS" by Andrew Schulman, Byte  Vol. 16, #3 (March 1991)
  160. */
  161. static int is_psp (WORD seg)
  162. {
  163.     return ((((MCB _far *) MK_FP(seg-1, 0))->owner == seg) &&
  164.            (*((WORD _far *) MK_FP(seg, 0)) == INT20h));
  165. }
  166.  
  167.  
  168. static WORD get_shell_psp_seg()
  169. {
  170.     PSP    _far *my_psp;
  171.     PSP    _far *parent_psp;
  172.  
  173.     /* get PSP address (int 21h fun 62h, DOS >= 3.0) */
  174.  
  175.     regs.h.ah = 0x62;
  176.  
  177.     intdos (®s, ®s);
  178.     
  179.     /* bx contains segment of PSP */
  180.  
  181.     my_psp = (PSP _far *)MK_FP(regs.x.bx, 0);
  182.  
  183.     do {
  184.         parent_psp = (PSP _far *)MK_FP(my_psp->parent_PSP, 0);
  185.         my_psp = parent_psp;
  186.     } while (parent_psp->parent_PSP != FP_SEG(parent_psp));
  187.  
  188.  
  189.     return FP_SEG(parent_psp);
  190. } 
  191.  
  192. static BYTEPTR get_envblock ()
  193. {
  194.     WORD    shell_psp_seg;
  195.     PSP _far *shell_psp;
  196.  
  197.     shell_psp_seg = get_shell_psp_seg();
  198.     shell_psp = (PSP _far *) MK_FP(shell_psp_seg, 0);
  199.  
  200.     return ((BYTEPTR) MK_FP(shell_psp->env_seg, 0));
  201. }
  202.  
  203. int iset_load_envstrings (BYTEPTR envblock, char *envstrings[], unsigned *pused)
  204. {
  205.     char _far *envpointer = (char _far *)envblock;
  206.     size_t len;
  207.     int    i = 0;
  208.  
  209.     while (*envpointer != '\0') {
  210.         len = _fstrlen (envpointer);
  211.         envstrings[i] = (char *) malloc (len + 1);
  212.         _fstrcpy ((char _far *) envstrings[i], envpointer);
  213.         envpointer += (len + 1);
  214.         ++i;
  215.     }
  216.     envstrings[i] = &terminating_null;
  217.     if (pused != (unsigned *)NULL)
  218.         *pused = (unsigned) (envpointer - envblock);
  219.  
  220.     return i;
  221. }
  222.  
  223. int iset_free_envstrings (char *envstrings[])
  224. {
  225.     int i = 0;
  226.  
  227.     while (envstrings[i][0] != '\0')
  228.         free (envstrings[i++]);
  229.  
  230.     return 0;
  231. }
  232.  
  233.     
  234. static int    search_string (char *string, char *array[])
  235. {
  236.     int i = 0;
  237.  
  238.     while (array[i][0] != '\0')
  239.     {
  240.         if (!strnicmp(array[i], string, strlen(string)))
  241.             return i;
  242.         else
  243.             i++;
  244.     }
  245.  
  246.     return -1;
  247. }
  248.  
  249.  
  250. /* works on original environment, which may be different
  251.    from our copy because of other iset_... function calls */
  252. char *iset_getenv (char *env_par)
  253. {
  254.     char *env_strings[128];
  255.     BYTEPTR    envblock;
  256.     int    maxstring;
  257.     int    i;
  258.     static char env_name[128];
  259.     static char env_value[256];
  260.     char    *return_this = NULL;
  261.     char    *equal;
  262.  
  263.     envblock = get_envblock();
  264.     maxstring = iset_load_envstrings (envblock, env_strings, NULL);
  265.  
  266.     env_value[0] = '\0';
  267.     for (i = 0; i < maxstring; i++) {
  268.         equal = strchr(env_strings[i], '=');
  269.         if (equal != NULL) {
  270.             strncpy (env_name, env_strings[i], equal - env_strings[i]);
  271.             env_name[equal - env_strings[i]]='\0';
  272.         }
  273.         else
  274.             strcpy (env_name, env_strings[i]);
  275.         if (!stricmp(env_name, env_par)) {
  276.             /* return value */
  277.             if (equal==NULL)
  278.                 env_value[0] = '\0';
  279.             else
  280.                 strcpy (env_value, ++equal);
  281.             return_this = env_value;
  282.             break;
  283.         }
  284.     }
  285.  
  286.  
  287.     iset_free_envstrings(env_strings);
  288.     return return_this;
  289. }
  290.     
  291.  
  292. int iset_delete_string (char *env_par)
  293. {
  294.     char *env_strings[128];
  295.     char *new_string;
  296.     BYTEPTR    envblock;
  297.     int    maxstring;
  298.     int    i;
  299.     int    this_one;
  300.     int    len;
  301.  
  302.     envblock = get_envblock();
  303.     maxstring = iset_load_envstrings (envblock, env_strings, NULL);
  304.  
  305.     if ((this_one = search_string(env_par, env_strings)) == -1)
  306.     {
  307.         /* string not found  - quietly exit */
  308.         return 1;
  309.     }
  310.  
  311.  
  312.     /* throw away old string */
  313.     new_string = env_strings[this_one];
  314.     free (new_string);
  315.     for (i = this_one; i < maxstring; i++)
  316.         env_strings[i] = env_strings[i + 1];
  317.     maxstring--;
  318.  
  319.     /* rebuild environment block */
  320.     for (i = 0; i <= maxstring; i++) {
  321.         len = strlen (env_strings[i]) + 1; /* copy null byte */
  322.         _fmemcpy(envblock, (void _far *)env_strings[i], len);
  323.         envblock += len;
  324.     }
  325.  
  326.     *envblock = '\0';
  327.  
  328.     iset_free_envstrings(env_strings);
  329.     return 0;
  330. }
  331.  
  332.  
  333. int iset_set_string (char *env_par, char *env_value)
  334. {
  335.     char *env_strings[128];
  336.     char *new_string;
  337.     BYTEPTR    envblock;
  338.     unsigned    envused;
  339.     unsigned    envfree;
  340.     int    maxstring;
  341.     int    i;
  342.     int    this_one;
  343.     int    len;
  344.     int    ret;
  345.  
  346.     if (iset_check_length(env_par, strlen(env_value) + strlen(env_par) + 2) !=0) {
  347.         return 1;
  348.     }
  349.  
  350.     envblock = get_envblock();
  351.     maxstring = iset_load_envstrings (envblock, env_strings, &envused);
  352.     envfree = env_size(FP_SEG(envblock)) - envused;
  353.  
  354.     if ((this_one = search_string(env_par, env_strings)) != -1)
  355.     {
  356. #ifdef ISETDEBUG
  357.         fprintf(stderr, "[D] Found existing %s\", env_strings[this_one]);
  358. #endif
  359.         /* throw away old string and add at the end */
  360.         new_string = env_strings[this_one];
  361.         envfree += (strlen(new_string) + 1);
  362.         free (new_string);
  363.         for (i = this_one; i < maxstring; i++)
  364.             env_strings[i] = env_strings[i + 1];
  365.         maxstring--;
  366.     }
  367.  
  368.     new_string = (char *)malloc (strlen(env_par) + strlen(env_value) + 2);
  369.  
  370.     if (env_value != NULL)
  371.         sprintf(new_string, "%s=%s", strupr(env_par), env_value);
  372.     else
  373.         strcpy (new_string, strupr (env_par));
  374.  
  375.     if (strlen(new_string) + 1 <= envfree)
  376.     {
  377.         env_strings[maxstring] = new_string;
  378.         ++maxstring;
  379.         env_strings[maxstring] = &terminating_null;
  380.  
  381.         /* rebuild environment block */
  382.  
  383.  
  384.         for (i = 0; i <= maxstring; i++) {
  385.             len = strlen (env_strings[i]) + 1; /* copy null byte */
  386.             _fmemcpy(envblock, (void _far *)env_strings[i], len);
  387.             envblock += len;
  388.         }
  389.  
  390.         *envblock = '\0';
  391.         ret = 0;
  392.     }
  393.     else
  394.         ret = 2;
  395.     iset_free_envstrings(env_strings);
  396.  
  397.     return ret;
  398. }
  399.  
  400. int    iset_append_to_string (char *env_par, char *env_value, int before)
  401. {
  402.     char        *env_strings[128];
  403.     register    char    *new_string;
  404.     char        *equal_sign;
  405.     BYTEPTR    envblock;
  406.     unsigned    envused;
  407.     unsigned    envfree;
  408.     int        maxstring;
  409.     int        i;
  410.     int        this_one;
  411.     int        len;
  412.     int        newlen;
  413.     int        ret;
  414.  
  415.     envblock = get_envblock();
  416.     maxstring = iset_load_envstrings (envblock, env_strings, &envused);
  417.     envfree = env_size(FP_SEG(envblock)) - envused;
  418.     if ((this_one = search_string(env_par, env_strings)) != -1)
  419.     {
  420. #ifdef ISETDEBUG
  421.         fprintf(stderr, "[D] Found existing %s\", env_strings[this_one]);
  422. #endif
  423.         /* append value to beginning of old string suffixing with a ; */
  424.         len = strlen(env_strings[this_one]) + strlen (env_value) + 2;    /* ; and  nul */
  425.         /* check existence of '=' in string. using iset_set_string
  426.            it is possible to create an assert-only var a la Unix. Now
  427.            we have to complete that. */
  428.         equal_sign = strchr(env_strings[this_one], '=');
  429.         if (equal_sign == (char *)NULL) 
  430.             ++len;
  431.         if (len - 1 > envfree)
  432.             ret = 2;
  433.         else {
  434.             if (iset_check_length(env_par, len) == 0) { 
  435.                 new_string = (char *) malloc (len);
  436.                 if (equal_sign == (char *)NULL) {
  437.                     strcpy(new_string, env_strings[this_one]);
  438.                     strcat(new_string, "=");
  439.                 }
  440.                 else {
  441.                     strncpy (new_string, env_strings[this_one], equal_sign - env_strings[this_one] + 1);
  442.                     new_string[equal_sign - env_strings[this_one] + 1] = '\0';
  443.                 }
  444.                 if (before) {
  445.                     strcat (new_string, env_value);
  446.                     strcat (new_string, ";");
  447.                     strcat (new_string, equal_sign + 1);
  448.                 }
  449.                 else    {
  450.                     if (strlen(equal_sign + 1) > 0) {
  451.                         strcat (new_string, equal_sign + 1);
  452.                         strcat (new_string, ";");
  453.                     }
  454.                     strcat (new_string, env_value);
  455.                 }
  456.  
  457.                 free (env_strings[this_one]);
  458.                 env_strings[this_one] = new_string;
  459.                 ret = 0;
  460.             } 
  461.             else
  462.                 ret = 1; 
  463.         }
  464.     }
  465.     else
  466.     {
  467.         /* simply set it */
  468.         len = strlen(env_par) + strlen(env_value) + 2;    /* = and nul */
  469.         if (len > envfree)
  470.             ret = 2;
  471.         else {
  472.             if (iset_check_length(env_par, strlen(env_value)) == 0) { 
  473.                 new_string = (char *)malloc (strlen(env_par) + strlen(env_value) + 2);
  474.                 if (env_value != NULL)
  475.                     sprintf(new_string, "%s=%s", strupr(env_par), env_value);
  476.                 else
  477.                     strcpy (new_string, strupr (env_par));
  478.                 env_strings[maxstring] = new_string;
  479.                 ++maxstring;
  480.                 env_strings[maxstring] = &terminating_null;
  481.                 ret = 0;
  482.             }
  483.             else
  484.                 ret = 1;
  485.         }
  486.     }
  487.  
  488.  
  489.  
  490.     if (ret == 0) {
  491.         /* rebuild environment block */
  492.         for (i = 0; i <= maxstring; i++) {
  493.             len = strlen (env_strings[i]) + 1; /* copy null byte */
  494.             _fmemcpy(envblock, (void _far *)env_strings[i], len);
  495.             envblock += len;
  496.         }
  497.  
  498.         *envblock = '\0';
  499.     }
  500.     iset_free_envstrings(env_strings);
  501.  
  502.     return ret;
  503. }
  504.  
  505.  
  506. int    iset_append_to_string_OLD (char *env_par, char *env_value)
  507. {
  508.     char        *env_strings[128];
  509.     char     *new_string;
  510.     BYTEPTR    envblock;
  511.     unsigned    envused;
  512.     unsigned    envfree;
  513.     int        maxstring;
  514.     int        i;
  515.     int        this_one;
  516.     int        len;
  517.     int        newlen;
  518.     int        ret;
  519.  
  520.     envblock = get_envblock();
  521.     maxstring = iset_load_envstrings (envblock, env_strings, &envused);
  522.     envfree = env_size(FP_SEG(envblock)) - envused;
  523.     if ((this_one = search_string(env_par, env_strings)) != -1)
  524.     {
  525. #ifdef ISETDEBUG
  526.         fprintf(stderr, "[D] Found existing %s\", env_strings[this_one]);
  527. #endif
  528.         /* append value to old string prefixing with a ; */
  529.         len = strlen (env_value) + 2;    /* ; and  nul */
  530.         if (len - 1 > envfree)
  531.             ret = 2;
  532.         else {
  533.             len+= strlen (env_strings[this_one]);
  534.             if (iset_check_length(env_par, len) == 0) { 
  535.                 new_string = (char *) malloc (len);
  536.                 strcpy (new_string, env_strings[this_one]);
  537.                 strcat (new_string, ";");
  538.                 strcat (new_string, env_value);
  539.                 free (env_strings[this_one]);
  540.                 env_strings[this_one] = new_string;
  541.                 ret = 0;
  542.             } 
  543.             else
  544.                 ret = 1; 
  545.         }
  546.     }
  547.     else
  548.     {
  549.         /* simply set it */
  550.         len = strlen(env_par) + strlen(env_value) + 2;    /* = and nul */
  551.         if (len > envfree)
  552.             ret = 2;
  553.         else {
  554.             if (iset_check_length(env_par, strlen(env_value)) == 0) { 
  555.                 new_string = (char *)malloc (strlen(env_par) + strlen(env_value) + 2);
  556.                 if (env_value != NULL)
  557.                     sprintf(new_string, "%s=%s", strupr(env_par), env_value);
  558.                 else
  559.                     strcpy (new_string, strupr (env_par));
  560.                 env_strings[maxstring] = new_string;
  561.                 ++maxstring;
  562.                 env_strings[maxstring] = &terminating_null;
  563.                 ret = 0;
  564.             }
  565.             else
  566.                 ret = 1;
  567.         }
  568.     }
  569.  
  570.  
  571.  
  572.     if (ret == 0) {
  573.         /* rebuild environment block */
  574.         for (i = 0; i <= maxstring; i++) {
  575.             len = strlen (env_strings[i]) + 1; /* copy null byte */
  576.             _fmemcpy(envblock, (void _far *)env_strings[i], len);
  577.             envblock += len;
  578.         }
  579.  
  580.         *envblock = '\0';
  581.     }
  582.     iset_free_envstrings(env_strings);
  583.  
  584.     return ret;
  585. }
  586.  
  587. int    iset_check_length(char *env_par, int len)
  588. {
  589.     /* special case: due to DOS limitations, and the PATH var
  590.        * can't exceed dos_max_pathvar_length(). So we have to test */
  591.     if (!stricmp(env_par, "PATH")) {
  592.         if (len > dos_max_pathvar_length()) {
  593.             fprintf(stderr, "%s: An environment variable cannot exceed 127 characters!\n", env_par);
  594.             return(1);
  595.         }
  596.     }
  597.     return (0);
  598. }
  599.  
  600. /* If the variable is not here, ignore.
  601.  * Else if there is no match with string_to_cut, ignore.
  602.  * Else take care of ";" contexts!
  603. */
  604. int iset_cut_string (char *env_par, char *string_to_cut)
  605. {
  606.     char    *env_strings[128];
  607.     char    *temp;
  608.     char *new_string;
  609.     char    *env_value;
  610.     char    *cutting_point;
  611.     char *next_piece;
  612.     char    *start_string;
  613.     char    *end_string;
  614.     BYTEPTR    envblock;
  615.     int    this_one;
  616.     int    i;
  617.     int    len;
  618.     int    maxstring;
  619.  
  620.     envblock = get_envblock();
  621.     maxstring = iset_load_envstrings (envblock, env_strings, NULL);
  622.     if ((this_one = search_string(env_par, env_strings)) != -1)
  623.     {
  624.         /* set value starting point */
  625.         if ((env_value = strchr(env_strings[this_one], '=')) != (char *)NULL) {
  626.             /* check match for string_to_cut */
  627.             /* take care: CASE SENSITIVE MATCH on value */
  628.             /* We must take care of ; context. */
  629.             if (strstr(++env_value, string_to_cut) != NULL) {
  630.                 temp = (char *)malloc(strlen(env_value + 1));
  631.                 start_string = env_value;
  632.                 do {
  633.                     if ((end_string = strchr(start_string, ';')) != (char *)NULL) {
  634.                         strncpy (temp, start_string, end_string - start_string);
  635.                         temp[end_string - start_string] = '\0';
  636.                     }
  637.                     else {
  638.                         strcpy (temp, start_string);
  639.                     }
  640.                     if (!strcmp(temp, string_to_cut)) {
  641.                         /* process cutting */
  642.                         strncpy (temp, env_value, start_string - env_value);
  643.                         temp[start_string - env_value]='\0';
  644.                         if (end_string != NULL)
  645.                             strcat (temp,++end_string);
  646.                         strcpy (env_value, temp);
  647.                         end_string = env_value + strlen(env_value) - 1;
  648.                         if (*end_string == ';')
  649.                             *end_string = '\0';
  650.                         break;    /* exit do...while */
  651.                     }
  652.                 } while (((start_string = end_string) != NULL) && ++start_string);
  653.                 free (temp);
  654.  
  655.             }
  656.          }    
  657.     }
  658.  
  659.  
  660.     for (i = 0; i <= maxstring; i++) {
  661.         /* don't copy string if orphaned (<var>= with no value) */
  662.         temp = env_strings[i];
  663.         if (temp[strlen(temp) - 1] != '=') {
  664.             len = strlen (env_strings[i]) + 1; /* copy null byte */
  665.             _fmemcpy(envblock, (void _far *)env_strings[i], len);
  666.             envblock += len;
  667.         }
  668.     }
  669.  
  670.     *envblock = '\0';
  671.     iset_free_envstrings(env_strings);
  672.  
  673.     return 0;
  674.         
  675.  
  676. }
  677.  
  678.     
  679.  
  680.  
  681. int iset_show_strings ()
  682. {
  683.     char *env_strings[128];
  684.     BYTEPTR    envblock;
  685.     unsigned    envsize;
  686.     unsigned    envused;
  687.     int    maxstring;
  688.     int    i;
  689.  
  690.     envblock = get_envblock();
  691.     maxstring = iset_load_envstrings (envblock, env_strings, &envused);
  692.     for (i = 0; i < maxstring; i++)
  693.         puts(env_strings[i]);
  694.     printf("********************************\n");
  695.     printf("Master environment at: %Fp\n", envblock);
  696.     printf("                 Size: %u\n", envsize = env_size(FP_SEG(envblock)));
  697.     printf("       No. of strings: %d\n", maxstring);
  698.     printf("           Bytes used: %u\n", envused);
  699.     printf("           Free space: %u\n", envsize - envused);
  700.     printf("********************************\n");
  701.  
  702.  
  703.  
  704.     iset_free_envstrings(env_strings);
  705.     return 0;
  706. }
  707.  
  708. #ifdef STANDALONE        
  709. main(int argc, char *argv[])
  710. {
  711.     POPTIONS    popt;
  712.     char        *s;
  713.  
  714.  
  715.     OPT_CREATE( popt, argc, argv );
  716.  
  717.     if (argc < 2 || Opt_IsSwitch (popt, 'h') || Opt_IsSwitch(popt, '?')) {
  718.         Syntax();
  719.         exit(-1);
  720.     }
  721.  
  722.     if (Opt_IsSwitch(popt, 'u')) {
  723.         if ((s = Opt_GetParameter (popt, 'u')) == NULL) {
  724.             Syntax();
  725.             exit(-1);
  726.         }
  727.         // delete string from environment 
  728.  
  729.         iset_delete_string (s);
  730.     }
  731.     else if (Opt_IsSwitch (popt, 's')) {
  732.         show_strings ();
  733.     }
  734.     else if (argc > 2)
  735.         iset_set_string (argv[1], argv[2]);
  736.     else 
  737.         iset_set_string (argv[1], NULL);
  738.  
  739.     return 0;
  740. }
  741.  
  742.  
  743. int Syntax ()
  744. {
  745.     puts ("I-Set " VERSIONE);
  746.     puts ("\tSintassi:     i-set <nomevar> [<valore>]");
  747.     puts ("\t              i-set [-u <nomevar>]");
  748.     puts ("\t              i-set -s");
  749.     puts ("\t              i-set -h │ -?");
  750.     puts ("\t-u (unset) elimina la variabile dalla tabella ambiente.");
  751.     puts ("\t-s (show) mostra il contenuto della tabella ambiente.");
  752.     puts ("\n (C) 1991 Shari, Inferentia S.r.l.");
  753.  
  754.     return 0;
  755. }
  756. #endif
  757.  
  758.  
  759.  
  760.  
  761.